package com.dragon.modules.yuegou.query.coupon;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.dragon.modules.yuegou.entity.coupon.CouponTemplateEntity;
import com.dragon.modules.yuegou.enums.coupon.CouponTemplateCheckedStatus;
import com.dragon.modules.yuegou.enums.coupon.CouponTemplateDivideType;
import com.dragon.modules.yuegou.enums.coupon.CouponTemplateFormat;
import com.dragon.modules.yuegou.enums.coupon.CouponTemplateOwnerType;
import com.dragon.modules.yuegou.enums.coupon.CouponTemplateScope;
import com.dragon.modules.yuegou.enums.coupon.CouponTemplateShelfStatus;
import com.dragon.modules.yuegou.enums.coupon.CouponTemplateTimeLimitType;
import com.dragon.modules.yuegou.enums.coupon.CouponTemplateType;
import com.dragon.modules.yuegou.enums.coupon.CouponTemplateViewModel;
import com.dragon.modules.yuegou.mybatis.Condition;
import com.dragon.modules.yuegou.mybatis.Query;
import com.fasterxml.jackson.annotation.JsonInclude;
import com.fasterxml.jackson.annotation.JsonInclude.Include;
import com.fasterxml.jackson.annotation.JsonUnwrapped;

import java.math.BigDecimal;
import java.time.LocalDateTime;

/**
 * 优惠券模板 动态查询条件
 * 
 * @author pbuilder generated
 * @date 2020-07-01 11:26:50
 * @version 2.0
 */
@JsonInclude(Include.NON_NULL)
public class CouponTemplateQuery extends CouponTemplateEntity implements Query<CouponTemplateEntity> {

    /** 优惠券模板ID查询条件 */
	@JsonUnwrapped(prefix = "id")
	private Condition<String> idCondition;

    /** [枚举]所有者类型(所有者承担成本)：0-平台-PLATFORM、1-集团-GROUP、2-商圈-BUSINESS_DISTRICT、3-商户-MERCHANT查询条件 */
	@JsonUnwrapped(prefix = "ownerType")
	private Condition<CouponTemplateOwnerType> ownerTypeCondition;

    /** 集团ID查询条件 */
	@JsonUnwrapped(prefix = "groupId")
	private Condition<String> groupIdCondition;

    /** 商圈ID查询条件 */
	@JsonUnwrapped(prefix = "busdId")
	private Condition<String> busdIdCondition;

    /** 商户ID查询条件 */
	@JsonUnwrapped(prefix = "merchantId")
	private Condition<String> merchantIdCondition;

    /** 优惠券标题查询条件 */
	@JsonUnwrapped(prefix = "title")
	private Condition<String> titleCondition;

    /** 优惠券图片地址查询条件 */
	@JsonUnwrapped(prefix = "imgUrl")
	private Condition<String> imgUrlCondition;

    /** 优惠券图表地址查询条件 */
	@JsonUnwrapped(prefix = "thumUrl")
	private Condition<String> thumUrlCondition;

    /** [枚举]时间限制类型：0-固定时段-FIXED_RANGE、1-有效天数-VALID_DAYS查询条件 */
	@JsonUnwrapped(prefix = "timeLimitType")
	private Condition<CouponTemplateTimeLimitType> timeLimitTypeCondition;

    /** 生效时间查询条件 */
	@JsonUnwrapped(prefix = "startTime")
	private Condition<LocalDateTime> startTimeCondition;

    /** 过期时间查询条件 */
	@JsonUnwrapped(prefix = "endTime")
	private Condition<LocalDateTime> endTimeCondition;

    /** 【停车券】失效天数（领取后能够有效的天数）查询条件 */
	@JsonUnwrapped(prefix = "validDays")
	private Condition<Integer> validDaysCondition;

    /** 【优惠券】失效小时（领取后能够有效的小时）查询条件 */
	@JsonUnwrapped(prefix = "validHours")
	private Condition<Integer> validHoursCondition;

    /** 总量查询条件 */
	@JsonUnwrapped(prefix = "stockTotal")
	private Condition<Integer> stockTotalCondition;

    /** [枚举]展示模块：0-商品详情-SPU_INFO查询条件 */
	@JsonUnwrapped(prefix = "viewModel")
	private Condition<CouponTemplateViewModel> viewModelCondition;

    /** 展示开始时间查询条件 */
	@JsonUnwrapped(prefix = "viewStartTime")
	private Condition<LocalDateTime> viewStartTimeCondition;

    /** 展示结束时间查询条件 */
	@JsonUnwrapped(prefix = "viewEndTime")
	private Condition<LocalDateTime> viewEndTimeCondition;

    /** [枚举]使用范围：0-全体商品-ALL、1-指定商圈-BUSINESS_DISTRICT、2-指定商户-MERCHANT、3-指定产品-SPU、4-指定商品类目-PRODUCT_CATEGORY、5-排除指定产品-EXCLUDE_SPU查询条件 */
	@JsonUnwrapped(prefix = "scope")
	private Condition<CouponTemplateScope> scopeCondition;

    /** 支持的使用场景（把数字看为二进制序列，从右往左数，第0位表示：悦币充值、第1位表示：购买悦卡、第2位表示：会员向商户支付、第3位表示：购买优惠券、第4位表示：购买券包、第5位表示：组局订单、第6位表示：购买实物商品、第7位表示：停车支付）查询条件 */
	@JsonUnwrapped(prefix = "scene")
	private Condition<Integer> sceneCondition;

    /** 支持的币种（把数字看为二进制序列，从右往左数，第0位表示：悦币、第1位表示：发放的悦卡、第2位表示：购买的悦卡、第3位表示：积分、第4位表示：第三方钱包）查询条件 */
	@JsonUnwrapped(prefix = "currency")
	private Condition<Integer> currencyCondition;

    /** 支持的获取优惠券通道（把数字看为二进制序列，从右往左数，第0位表示：购买、第1位表示：积分兑换、第2位表示：小票兑换）查询条件 */
	@JsonUnwrapped(prefix = "channel")
	private Condition<Integer> channelCondition;

    /** [枚举]优惠券类型：0-停车券-PARK、1-现金券-CASH查询条件 */
	@JsonUnwrapped(prefix = "type")
	private Condition<CouponTemplateType> typeCondition;

    /** [枚举]优惠形式：0-抵扣券-DEDUCATION、1-折扣券-DISCOUNT、2-随机券-RANDOM查询条件 */
	@JsonUnwrapped(prefix = "format")
	private Condition<CouponTemplateFormat> formatCondition;

    /** [抵扣券]抵扣金额（0.00表示无抵扣）[随机券]最高总金额查询条件 */
	@JsonUnwrapped(prefix = "reductionMount")
	private Condition<BigDecimal> reductionMountCondition;

    /** [折扣券]折扣率（0.00~1.00，例如九五折：0.95，1.00表示无折扣）查询条件 */
	@JsonUnwrapped(prefix = "discountRate")
	private Condition<BigDecimal> discountRateCondition;

    /** [随机券]抵扣金额下限查询条件 */
	@JsonUnwrapped(prefix = "lowerDiscount")
	private Condition<BigDecimal> lowerDiscountCondition;

    /** [随机券]抵扣金额上限查询条件 */
	@JsonUnwrapped(prefix = "upperDiscount")
	private Condition<BigDecimal> upperDiscountCondition;

    /** 使用门槛下限（包含，即订单满多少才能使用，-1.00表示不限制）查询条件 */
	@JsonUnwrapped(prefix = "lowerLimit")
	private Condition<BigDecimal> lowerLimitCondition;

    /** 使用门槛上限（包含，-1.00表示不限制）查询条件 */
	@JsonUnwrapped(prefix = "upperLimit")
	private Condition<BigDecimal> upperLimitCondition;

    /** 每人限领张数（-1表示不限制）查询条件 */
	@JsonUnwrapped(prefix = "personalLimit")
	private Condition<Integer> personalLimitCondition;

    /** 每人/每天限领张数（-1表示不限制）查询条件 */
	@JsonUnwrapped(prefix = "personalDayLimit")
	private Condition<Integer> personalDayLimitCondition;

    /** 会员等级限制（-1表示不限制，1表示等级大于等于1级的会员可以用，以此类推）查询条件 */
	@JsonUnwrapped(prefix = "memberLevelLimit")
	private Condition<Integer> memberLevelLimitCondition;

    /** 是否允许售卖（1：允许售卖、2：不允许售卖）查询条件 */
	@JsonUnwrapped(prefix = "allowSale")
	private Condition<Boolean> allowSaleCondition;

    /** 是否允许重叠查询条件 */
	@JsonUnwrapped(prefix = "allowCpys")
	private Condition<Boolean> allowCpysCondition;

    /** 提前预警小时查询条件 */
	@JsonUnwrapped(prefix = "expireWarnHour")
	private Condition<Integer> expireWarnHourCondition;

    /** [枚举]分摊方式：0-百分比-SCALE、1-现金-CASH查询条件 */
	@JsonUnwrapped(prefix = "divideType")
	private Condition<CouponTemplateDivideType> divideTypeCondition;

    /** 商户分摊（现金或者比例，比例之和=1，现金之和=reduction_mount）查询条件 */
	@JsonUnwrapped(prefix = "divideMerchant")
	private Condition<BigDecimal> divideMerchantCondition;

    /** 平台分摊（现金或者比例，比例之和=1，现金之和=reduction_mount）查询条件 */
	@JsonUnwrapped(prefix = "divideGroup")
	private Condition<BigDecimal> divideGroupCondition;

    /** 优惠券描述查询条件 */
	@JsonUnwrapped(prefix = "discription")
	private Condition<String> discriptionCondition;

    /** 优惠券备注查询条件 */
	@JsonUnwrapped(prefix = "remarks")
	private Condition<String> remarksCondition;

    /** 排序号查询条件 */
	@JsonUnwrapped(prefix = "sort")
	private Condition<Integer> sortCondition;

    /** [枚举]上架状态：0-已下架-OFF_SHELF、1-已上架-ON_SHELF查询条件 */
	@JsonUnwrapped(prefix = "shelfStatus")
	private Condition<CouponTemplateShelfStatus> shelfStatusCondition;

    /** 创建者查询条件 */
	@JsonUnwrapped(prefix = "createdBy")
	private Condition<String> createdByCondition;

    /** 创建时间查询条件 */
	@JsonUnwrapped(prefix = "createdTime")
	private Condition<LocalDateTime> createdTimeCondition;

    /** 修改人查询条件 */
	@JsonUnwrapped(prefix = "modifiedBy")
	private Condition<String> modifiedByCondition;

    /** 修改时间查询条件 */
	@JsonUnwrapped(prefix = "modifiedTime")
	private Condition<LocalDateTime> modifiedTimeCondition;

    /** 是否删除（1：已删除，0：未删除）查询条件 */
	@JsonUnwrapped(prefix = "del")
	private Condition<Boolean> delCondition;

    /** 删除人查询条件 */
	@JsonUnwrapped(prefix = "delBy")
	private Condition<String> delByCondition;

    /** 删除时间查询条件 */
	@JsonUnwrapped(prefix = "delTime")
	private Condition<LocalDateTime> delTimeCondition;

    /** [枚举]审核状态：0-待提交-NOT_SUBMITTED、1-审核中-CHECKING、2-已通过-PASSED、3-审核未通过-UNPASSED查询条件 */
	@JsonUnwrapped(prefix = "checkedStatus")
	private Condition<CouponTemplateCheckedStatus> checkedStatusCondition;

    /** 审核人查询条件 */
	@JsonUnwrapped(prefix = "checkedBy")
	private Condition<String> checkedByCondition;

    /** 审核时间查询条件 */
	@JsonUnwrapped(prefix = "checkedTime")
	private Condition<LocalDateTime> checkedTimeCondition;

    /** 审核意见查询条件 */
	@JsonUnwrapped(prefix = "checkedRemark")
	private Condition<String> checkedRemarkCondition;

	/**
	 * 构造一个查询条件对象
	 */
	public CouponTemplateQuery() {
		super();
	}

	/**
	 * 依据实体对象构造一个查询条件对象
	 * 
	 * @param entity 实体对象
	 */
	public CouponTemplateQuery(CouponTemplateEntity entity) {
		super(entity);
	}

	/**
	 * 依据其它查询条件对象的信息构造一个查询条件对象
	 * 
	 * @param other 查询条件对象
	 */
	public CouponTemplateQuery(CouponTemplateQuery other) {
		super(other);
		if(other.idCondition != null) {
			this.idCondition = other.idCondition.copy();
		}
		if(other.ownerTypeCondition != null) {
			this.ownerTypeCondition = other.ownerTypeCondition.copy();
		}
		if(other.groupIdCondition != null) {
			this.groupIdCondition = other.groupIdCondition.copy();
		}
		if(other.busdIdCondition != null) {
			this.busdIdCondition = other.busdIdCondition.copy();
		}
		if(other.merchantIdCondition != null) {
			this.merchantIdCondition = other.merchantIdCondition.copy();
		}
		if(other.titleCondition != null) {
			this.titleCondition = other.titleCondition.copy();
		}
		if(other.imgUrlCondition != null) {
			this.imgUrlCondition = other.imgUrlCondition.copy();
		}
		if(other.thumUrlCondition != null) {
			this.thumUrlCondition = other.thumUrlCondition.copy();
		}
		if(other.timeLimitTypeCondition != null) {
			this.timeLimitTypeCondition = other.timeLimitTypeCondition.copy();
		}
		if(other.startTimeCondition != null) {
			this.startTimeCondition = other.startTimeCondition.copy();
		}
		if(other.endTimeCondition != null) {
			this.endTimeCondition = other.endTimeCondition.copy();
		}
		if(other.validDaysCondition != null) {
			this.validDaysCondition = other.validDaysCondition.copy();
		}
		if(other.validHoursCondition != null) {
			this.validHoursCondition = other.validHoursCondition.copy();
		}
		if(other.stockTotalCondition != null) {
			this.stockTotalCondition = other.stockTotalCondition.copy();
		}
		this.setOther(other);
	}
	private void setOther(CouponTemplateQuery other){
		if(other.viewModelCondition != null) {
			this.viewModelCondition = other.viewModelCondition.copy();
		}
		if(other.viewStartTimeCondition != null) {
			this.viewStartTimeCondition = other.viewStartTimeCondition.copy();
		}
		if(other.viewEndTimeCondition != null) {
			this.viewEndTimeCondition = other.viewEndTimeCondition.copy();
		}
		if(other.scopeCondition != null) {
			this.scopeCondition = other.scopeCondition.copy();
		}
		if(other.sceneCondition != null) {
			this.sceneCondition = other.sceneCondition.copy();
		}
		if(other.currencyCondition != null) {
			this.currencyCondition = other.currencyCondition.copy();
		}
		if(other.channelCondition != null) {
			this.channelCondition = other.channelCondition.copy();
		}
		if(other.typeCondition != null) {
			this.typeCondition = other.typeCondition.copy();
		}
		if(other.formatCondition != null) {
			this.formatCondition = other.formatCondition.copy();
		}
		if(other.reductionMountCondition != null) {
			this.reductionMountCondition = other.reductionMountCondition.copy();
		}
		if(other.discountRateCondition != null) {
			this.discountRateCondition = other.discountRateCondition.copy();
		}
		if(other.lowerDiscountCondition != null) {
			this.lowerDiscountCondition = other.lowerDiscountCondition.copy();
		}
		if(other.upperDiscountCondition != null) {
			this.upperDiscountCondition = other.upperDiscountCondition.copy();
		}
		if(other.lowerLimitCondition != null) {
			this.lowerLimitCondition = other.lowerLimitCondition.copy();
		}
		this.setOther2(other);
	}
	private void setOther2(CouponTemplateQuery other){
		if(other.upperLimitCondition != null) {
			this.upperLimitCondition = other.upperLimitCondition.copy();
		}
		if(other.personalLimitCondition != null) {
			this.personalLimitCondition = other.personalLimitCondition.copy();
		}
		if(other.personalDayLimitCondition != null) {
			this.personalDayLimitCondition = other.personalDayLimitCondition.copy();
		}
		if(other.memberLevelLimitCondition != null) {
			this.memberLevelLimitCondition = other.memberLevelLimitCondition.copy();
		}
		if(other.allowSaleCondition != null) {
			this.allowSaleCondition = other.allowSaleCondition.copy();
		}
		if(other.allowCpysCondition != null) {
			this.allowCpysCondition = other.allowCpysCondition.copy();
		}
		if(other.expireWarnHourCondition != null) {
			this.expireWarnHourCondition = other.expireWarnHourCondition.copy();
		}
		if(other.divideTypeCondition != null) {
			this.divideTypeCondition = other.divideTypeCondition.copy();
		}
		if(other.divideMerchantCondition != null) {
			this.divideMerchantCondition = other.divideMerchantCondition.copy();
		}
		if(other.divideGroupCondition != null) {
			this.divideGroupCondition = other.divideGroupCondition.copy();
		}
		if(other.discriptionCondition != null) {
			this.discriptionCondition = other.discriptionCondition.copy();
		}
		if(other.remarksCondition != null) {
			this.remarksCondition = other.remarksCondition.copy();
		}
		if(other.sortCondition != null) {
			this.sortCondition = other.sortCondition.copy();
		}
		if(other.shelfStatusCondition != null) {
			this.shelfStatusCondition = other.shelfStatusCondition.copy();
		}
		this.setOther3(other);
	}
	private void setOther3(CouponTemplateQuery other){
		if(other.createdByCondition != null) {
			this.createdByCondition = other.createdByCondition.copy();
		}
		if(other.createdTimeCondition != null) {
			this.createdTimeCondition = other.createdTimeCondition.copy();
		}
		if(other.modifiedByCondition != null) {
			this.modifiedByCondition = other.modifiedByCondition.copy();
		}
		if(other.modifiedTimeCondition != null) {
			this.modifiedTimeCondition = other.modifiedTimeCondition.copy();
		}
		if(other.delCondition != null) {
			this.delCondition = other.delCondition.copy();
		}
		if(other.delByCondition != null) {
			this.delByCondition = other.delByCondition.copy();
		}
		if(other.delTimeCondition != null) {
			this.delTimeCondition = other.delTimeCondition.copy();
		}
		if(other.checkedStatusCondition != null) {
			this.checkedStatusCondition = other.checkedStatusCondition.copy();
		}
		if(other.checkedByCondition != null) {
			this.checkedByCondition = other.checkedByCondition.copy();
		}
		if(other.checkedTimeCondition != null) {
			this.checkedTimeCondition = other.checkedTimeCondition.copy();
		}
		if(other.checkedRemarkCondition != null) {
			this.checkedRemarkCondition = other.checkedRemarkCondition.copy();
		}
	}

	@Override
	public QueryWrapper<CouponTemplateEntity> toQueryWrapper() {
		QueryWrapper<CouponTemplateEntity> wrapper = new QueryWrapper<>(this);
		if (idCondition != null) {
			idCondition.toWrapper(wrapper, COL_ID);
		}
		if (ownerTypeCondition != null) {
			ownerTypeCondition.toWrapper(wrapper, COL_OWNER_TYPE);
		}
		if (groupIdCondition != null) {
			groupIdCondition.toWrapper(wrapper, COL_GROUP_ID);
		}
		if (busdIdCondition != null) {
			busdIdCondition.toWrapper(wrapper, COL_BUSD_ID);
		}
		if (merchantIdCondition != null) {
			merchantIdCondition.toWrapper(wrapper, COL_MERCHANT_ID);
		}
		if (titleCondition != null) {
			titleCondition.toWrapper(wrapper, COL_TITLE);
		}
		if (imgUrlCondition != null) {
			imgUrlCondition.toWrapper(wrapper, COL_IMG_URL);
		}
		if (thumUrlCondition != null) {
			thumUrlCondition.toWrapper(wrapper, COL_THUM_URL);
		}
		if (timeLimitTypeCondition != null) {
			timeLimitTypeCondition.toWrapper(wrapper, COL_TIME_LIMIT_TYPE);
		}
		if (startTimeCondition != null) {
			startTimeCondition.toWrapper(wrapper, COL_START_TIME);
		}
		if (endTimeCondition != null) {
			endTimeCondition.toWrapper(wrapper, COL_END_TIME);
		}
		if (validDaysCondition != null) {
			validDaysCondition.toWrapper(wrapper, COL_VALID_DAYS);
		}
		if (validHoursCondition != null) {
			validHoursCondition.toWrapper(wrapper, COL_VALID_HOURS);
		}
		if (stockTotalCondition != null) {
			stockTotalCondition.toWrapper(wrapper, COL_STOCK_TOTAL);
		}
		return getQueryWrapper(wrapper);
	}
	private QueryWrapper<CouponTemplateEntity> getQueryWrapper(QueryWrapper<CouponTemplateEntity> wrapper){
		if (viewModelCondition != null) {
			viewModelCondition.toWrapper(wrapper, COL_VIEW_MODEL);
		}
		if (viewStartTimeCondition != null) {
			viewStartTimeCondition.toWrapper(wrapper, COL_VIEW_START_TIME);
		}
		if (viewEndTimeCondition != null) {
			viewEndTimeCondition.toWrapper(wrapper, COL_VIEW_END_TIME);
		}
		if (scopeCondition != null) {
			scopeCondition.toWrapper(wrapper, COL_SCOPE);
		}
		if (sceneCondition != null) {
			sceneCondition.toWrapper(wrapper, COL_SCENE);
		}
		if (currencyCondition != null) {
			currencyCondition.toWrapper(wrapper, COL_CURRENCY);
		}
		if (channelCondition != null) {
			channelCondition.toWrapper(wrapper, COL_CHANNEL);
		}
		if (typeCondition != null) {
			typeCondition.toWrapper(wrapper, COL_TYPE);
		}
		if (formatCondition != null) {
			formatCondition.toWrapper(wrapper, COL_FORMAT);
		}
		if (reductionMountCondition != null) {
			reductionMountCondition.toWrapper(wrapper, COL_REDUCTION_MOUNT);
		}
		if (discountRateCondition != null) {
			discountRateCondition.toWrapper(wrapper, COL_DISCOUNT_RATE);
		}
		if (lowerDiscountCondition != null) {
			lowerDiscountCondition.toWrapper(wrapper, COL_LOWER_DISCOUNT);
		}
		if (upperDiscountCondition != null) {
			upperDiscountCondition.toWrapper(wrapper, COL_UPPER_DISCOUNT);
		}
		if (lowerLimitCondition != null) {
			lowerLimitCondition.toWrapper(wrapper, COL_LOWER_LIMIT);
		}
		return getQueryWrapper2(wrapper);
	}
	private QueryWrapper<CouponTemplateEntity> getQueryWrapper2(QueryWrapper<CouponTemplateEntity> wrapper){
		if (upperLimitCondition != null) {
			upperLimitCondition.toWrapper(wrapper, COL_UPPER_LIMIT);
		}
		if (personalLimitCondition != null) {
			personalLimitCondition.toWrapper(wrapper, COL_PERSONAL_LIMIT);
		}
		if (personalDayLimitCondition != null) {
			personalDayLimitCondition.toWrapper(wrapper, COL_PERSONAL_DAY_LIMIT);
		}
		if (memberLevelLimitCondition != null) {
			memberLevelLimitCondition.toWrapper(wrapper, COL_MEMBER_LEVEL_LIMIT);
		}
		if (allowSaleCondition != null) {
			allowSaleCondition.toWrapper(wrapper, COL_ALLOW_SALE);
		}
		if (allowCpysCondition != null) {
			allowCpysCondition.toWrapper(wrapper, COL_ALLOW_CPYS);
		}
		if (expireWarnHourCondition != null) {
			expireWarnHourCondition.toWrapper(wrapper, COL_EXPIRE_WARN_HOUR);
		}
		if (divideTypeCondition != null) {
			divideTypeCondition.toWrapper(wrapper, COL_DIVIDE_TYPE);
		}
		if (divideMerchantCondition != null) {
			divideMerchantCondition.toWrapper(wrapper, COL_DIVIDE_MERCHANT);
		}
		if (divideGroupCondition != null) {
			divideGroupCondition.toWrapper(wrapper, COL_DIVIDE_GROUP);
		}
		if (discriptionCondition != null) {
			discriptionCondition.toWrapper(wrapper, COL_DISCRIPTION);
		}
		if (remarksCondition != null) {
			remarksCondition.toWrapper(wrapper, COL_REMARKS);
		}
		if (sortCondition != null) {
			sortCondition.toWrapper(wrapper, COL_SORT);
		}
		if (shelfStatusCondition != null) {
			shelfStatusCondition.toWrapper(wrapper, COL_SHELF_STATUS);
		}
		return getQueryWrapper3(wrapper);
	}
	private QueryWrapper<CouponTemplateEntity> getQueryWrapper3(QueryWrapper<CouponTemplateEntity> wrapper){
		if (createdByCondition != null) {
			createdByCondition.toWrapper(wrapper, COL_CREATED_BY);
		}
		if (createdTimeCondition != null) {
			createdTimeCondition.toWrapper(wrapper, COL_CREATED_TIME);
		}
		if (modifiedByCondition != null) {
			modifiedByCondition.toWrapper(wrapper, COL_MODIFIED_BY);
		}
		if (modifiedTimeCondition != null) {
			modifiedTimeCondition.toWrapper(wrapper, COL_MODIFIED_TIME);
		}
		if (delCondition != null) {
			delCondition.toWrapper(wrapper, COL_DEL);
		}
		if (delByCondition != null) {
			delByCondition.toWrapper(wrapper, COL_DEL_BY);
		}
		if (delTimeCondition != null) {
			delTimeCondition.toWrapper(wrapper, COL_DEL_TIME);
		}
		if (checkedStatusCondition != null) {
			checkedStatusCondition.toWrapper(wrapper, COL_CHECKED_STATUS);
		}
		if (checkedByCondition != null) {
			checkedByCondition.toWrapper(wrapper, COL_CHECKED_BY);
		}
		if (checkedTimeCondition != null) {
			checkedTimeCondition.toWrapper(wrapper, COL_CHECKED_TIME);
		}
		if (checkedRemarkCondition != null) {
			checkedRemarkCondition.toWrapper(wrapper, COL_CHECKED_REMARK);
		}
		return wrapper;
	}

	/**
	 * 构造并返回优惠券模板ID查询条件
	 * 
	 * @return idCondition 优惠券模板ID查询条件
	 */
	public Condition<String> id() {
		this.idCondition = new Condition<>();
		return this.idCondition;
	}
	
	/**
	 * 获取优惠券模板ID查询条件
	 * 
	 * @return idCondition 优惠券模板ID查询条件
	 */
	public Condition<String> getIdCondition() {
		return idCondition;
	}

	/**
	 * 设置优惠券模板ID查询条件
	 * 
	 * @param idCondition 优惠券模板ID查询条件
	 */
	public void setIdCondition(Condition<String> idCondition) {
		this.idCondition = idCondition;
	}

	/**
	 * 构造并返回[枚举]所有者类型(所有者承担成本)：0-平台-PLATFORM、1-集团-GROUP、2-商圈-BUSINESS_DISTRICT、3-商户-MERCHANT查询条件
	 * 
	 * @return ownerTypeCondition [枚举]所有者类型(所有者承担成本)：0-平台-PLATFORM、1-集团-GROUP、2-商圈-BUSINESS_DISTRICT、3-商户-MERCHANT查询条件
	 */
	public Condition<CouponTemplateOwnerType> ownerType() {
		this.ownerTypeCondition = new Condition<>();
		return this.ownerTypeCondition;
	}
	
	/**
	 * 获取[枚举]所有者类型(所有者承担成本)：0-平台-PLATFORM、1-集团-GROUP、2-商圈-BUSINESS_DISTRICT、3-商户-MERCHANT查询条件
	 * 
	 * @return ownerTypeCondition [枚举]所有者类型(所有者承担成本)：0-平台-PLATFORM、1-集团-GROUP、2-商圈-BUSINESS_DISTRICT、3-商户-MERCHANT查询条件
	 */
	public Condition<CouponTemplateOwnerType> getOwnerTypeCondition() {
		return ownerTypeCondition;
	}

	/**
	 * 设置[枚举]所有者类型(所有者承担成本)：0-平台-PLATFORM、1-集团-GROUP、2-商圈-BUSINESS_DISTRICT、3-商户-MERCHANT查询条件
	 * 
	 * @param ownerTypeCondition [枚举]所有者类型(所有者承担成本)：0-平台-PLATFORM、1-集团-GROUP、2-商圈-BUSINESS_DISTRICT、3-商户-MERCHANT查询条件
	 */
	public void setOwnerTypeCondition(Condition<CouponTemplateOwnerType> ownerTypeCondition) {
		this.ownerTypeCondition = ownerTypeCondition;
	}

	/**
	 * 构造并返回集团ID查询条件
	 * 
	 * @return groupIdCondition 集团ID查询条件
	 */
	public Condition<String> groupId() {
		this.groupIdCondition = new Condition<>();
		return this.groupIdCondition;
	}
	
	/**
	 * 获取集团ID查询条件
	 * 
	 * @return groupIdCondition 集团ID查询条件
	 */
	public Condition<String> getGroupIdCondition() {
		return groupIdCondition;
	}

	/**
	 * 设置集团ID查询条件
	 * 
	 * @param groupIdCondition 集团ID查询条件
	 */
	public void setGroupIdCondition(Condition<String> groupIdCondition) {
		this.groupIdCondition = groupIdCondition;
	}

	/**
	 * 构造并返回商圈ID查询条件
	 * 
	 * @return busdIdCondition 商圈ID查询条件
	 */
	public Condition<String> busdId() {
		this.busdIdCondition = new Condition<>();
		return this.busdIdCondition;
	}
	
	/**
	 * 获取商圈ID查询条件
	 * 
	 * @return busdIdCondition 商圈ID查询条件
	 */
	public Condition<String> getBusdIdCondition() {
		return busdIdCondition;
	}

	/**
	 * 设置商圈ID查询条件
	 * 
	 * @param busdIdCondition 商圈ID查询条件
	 */
	public void setBusdIdCondition(Condition<String> busdIdCondition) {
		this.busdIdCondition = busdIdCondition;
	}

	/**
	 * 构造并返回商户ID查询条件
	 * 
	 * @return merchantIdCondition 商户ID查询条件
	 */
	public Condition<String> merchantId() {
		this.merchantIdCondition = new Condition<>();
		return this.merchantIdCondition;
	}
	
	/**
	 * 获取商户ID查询条件
	 * 
	 * @return merchantIdCondition 商户ID查询条件
	 */
	public Condition<String> getMerchantIdCondition() {
		return merchantIdCondition;
	}

	/**
	 * 设置商户ID查询条件
	 * 
	 * @param merchantIdCondition 商户ID查询条件
	 */
	public void setMerchantIdCondition(Condition<String> merchantIdCondition) {
		this.merchantIdCondition = merchantIdCondition;
	}

	/**
	 * 构造并返回优惠券标题查询条件
	 * 
	 * @return titleCondition 优惠券标题查询条件
	 */
	public Condition<String> title() {
		this.titleCondition = new Condition<>();
		return this.titleCondition;
	}
	
	/**
	 * 获取优惠券标题查询条件
	 * 
	 * @return titleCondition 优惠券标题查询条件
	 */
	public Condition<String> getTitleCondition() {
		return titleCondition;
	}

	/**
	 * 设置优惠券标题查询条件
	 * 
	 * @param titleCondition 优惠券标题查询条件
	 */
	public void setTitleCondition(Condition<String> titleCondition) {
		this.titleCondition = titleCondition;
	}

	/**
	 * 构造并返回优惠券图片地址查询条件
	 * 
	 * @return imgUrlCondition 优惠券图片地址查询条件
	 */
	public Condition<String> imgUrl() {
		this.imgUrlCondition = new Condition<>();
		return this.imgUrlCondition;
	}
	
	/**
	 * 获取优惠券图片地址查询条件
	 * 
	 * @return imgUrlCondition 优惠券图片地址查询条件
	 */
	public Condition<String> getImgUrlCondition() {
		return imgUrlCondition;
	}

	/**
	 * 设置优惠券图片地址查询条件
	 * 
	 * @param imgUrlCondition 优惠券图片地址查询条件
	 */
	public void setImgUrlCondition(Condition<String> imgUrlCondition) {
		this.imgUrlCondition = imgUrlCondition;
	}

	/**
	 * 构造并返回优惠券图表地址查询条件
	 * 
	 * @return thumUrlCondition 优惠券图表地址查询条件
	 */
	public Condition<String> thumUrl() {
		this.thumUrlCondition = new Condition<>();
		return this.thumUrlCondition;
	}
	
	/**
	 * 获取优惠券图表地址查询条件
	 * 
	 * @return thumUrlCondition 优惠券图表地址查询条件
	 */
	public Condition<String> getThumUrlCondition() {
		return thumUrlCondition;
	}

	/**
	 * 设置优惠券图表地址查询条件
	 * 
	 * @param thumUrlCondition 优惠券图表地址查询条件
	 */
	public void setThumUrlCondition(Condition<String> thumUrlCondition) {
		this.thumUrlCondition = thumUrlCondition;
	}

	/**
	 * 构造并返回[枚举]时间限制类型：0-固定时段-FIXED_RANGE、1-有效天数-VALID_DAYS查询条件
	 * 
	 * @return timeLimitTypeCondition [枚举]时间限制类型：0-固定时段-FIXED_RANGE、1-有效天数-VALID_DAYS查询条件
	 */
	public Condition<CouponTemplateTimeLimitType> timeLimitType() {
		this.timeLimitTypeCondition = new Condition<>();
		return this.timeLimitTypeCondition;
	}
	
	/**
	 * 获取[枚举]时间限制类型：0-固定时段-FIXED_RANGE、1-有效天数-VALID_DAYS查询条件
	 * 
	 * @return timeLimitTypeCondition [枚举]时间限制类型：0-固定时段-FIXED_RANGE、1-有效天数-VALID_DAYS查询条件
	 */
	public Condition<CouponTemplateTimeLimitType> getTimeLimitTypeCondition() {
		return timeLimitTypeCondition;
	}

	/**
	 * 设置[枚举]时间限制类型：0-固定时段-FIXED_RANGE、1-有效天数-VALID_DAYS查询条件
	 * 
	 * @param timeLimitTypeCondition [枚举]时间限制类型：0-固定时段-FIXED_RANGE、1-有效天数-VALID_DAYS查询条件
	 */
	public void setTimeLimitTypeCondition(Condition<CouponTemplateTimeLimitType> timeLimitTypeCondition) {
		this.timeLimitTypeCondition = timeLimitTypeCondition;
	}

	/**
	 * 构造并返回生效时间查询条件
	 * 
	 * @return startTimeCondition 生效时间查询条件
	 */
	public Condition<LocalDateTime> startTime() {
		this.startTimeCondition = new Condition<>();
		return this.startTimeCondition;
	}
	
	/**
	 * 获取生效时间查询条件
	 * 
	 * @return startTimeCondition 生效时间查询条件
	 */
	public Condition<LocalDateTime> getStartTimeCondition() {
		return startTimeCondition;
	}

	/**
	 * 设置生效时间查询条件
	 * 
	 * @param startTimeCondition 生效时间查询条件
	 */
	public void setStartTimeCondition(Condition<LocalDateTime> startTimeCondition) {
		this.startTimeCondition = startTimeCondition;
	}

	/**
	 * 构造并返回过期时间查询条件
	 * 
	 * @return endTimeCondition 过期时间查询条件
	 */
	public Condition<LocalDateTime> endTime() {
		this.endTimeCondition = new Condition<>();
		return this.endTimeCondition;
	}
	
	/**
	 * 获取过期时间查询条件
	 * 
	 * @return endTimeCondition 过期时间查询条件
	 */
	public Condition<LocalDateTime> getEndTimeCondition() {
		return endTimeCondition;
	}

	/**
	 * 设置过期时间查询条件
	 * 
	 * @param endTimeCondition 过期时间查询条件
	 */
	public void setEndTimeCondition(Condition<LocalDateTime> endTimeCondition) {
		this.endTimeCondition = endTimeCondition;
	}

	/**
	 * 构造并返回【停车券】失效天数（领取后能够有效的天数）查询条件
	 * 
	 * @return validDaysCondition 【停车券】失效天数（领取后能够有效的天数）查询条件
	 */
	public Condition<Integer> validDays() {
		this.validDaysCondition = new Condition<>();
		return this.validDaysCondition;
	}
	
	/**
	 * 获取【停车券】失效天数（领取后能够有效的天数）查询条件
	 * 
	 * @return validDaysCondition 【停车券】失效天数（领取后能够有效的天数）查询条件
	 */
	public Condition<Integer> getValidDaysCondition() {
		return validDaysCondition;
	}

	/**
	 * 设置【停车券】失效天数（领取后能够有效的天数）查询条件
	 * 
	 * @param validDaysCondition 【停车券】失效天数（领取后能够有效的天数）查询条件
	 */
	public void setValidDaysCondition(Condition<Integer> validDaysCondition) {
		this.validDaysCondition = validDaysCondition;
	}

	/**
	 * 构造并返回【优惠券】失效小时（领取后能够有效的小时）查询条件
	 * 
	 * @return validHoursCondition 【优惠券】失效小时（领取后能够有效的小时）查询条件
	 */
	public Condition<Integer> validHours() {
		this.validHoursCondition = new Condition<>();
		return this.validHoursCondition;
	}
	
	/**
	 * 获取【优惠券】失效小时（领取后能够有效的小时）查询条件
	 * 
	 * @return validHoursCondition 【优惠券】失效小时（领取后能够有效的小时）查询条件
	 */
	public Condition<Integer> getValidHoursCondition() {
		return validHoursCondition;
	}

	/**
	 * 设置【优惠券】失效小时（领取后能够有效的小时）查询条件
	 * 
	 * @param validHoursCondition 【优惠券】失效小时（领取后能够有效的小时）查询条件
	 */
	public void setValidHoursCondition(Condition<Integer> validHoursCondition) {
		this.validHoursCondition = validHoursCondition;
	}

	/**
	 * 构造并返回总量查询条件
	 * 
	 * @return stockTotalCondition 总量查询条件
	 */
	public Condition<Integer> stockTotal() {
		this.stockTotalCondition = new Condition<>();
		return this.stockTotalCondition;
	}
	
	/**
	 * 获取总量查询条件
	 * 
	 * @return stockTotalCondition 总量查询条件
	 */
	public Condition<Integer> getStockTotalCondition() {
		return stockTotalCondition;
	}

	/**
	 * 设置总量查询条件
	 * 
	 * @param stockTotalCondition 总量查询条件
	 */
	public void setStockTotalCondition(Condition<Integer> stockTotalCondition) {
		this.stockTotalCondition = stockTotalCondition;
	}

	/**
	 * 构造并返回[枚举]展示模块：0-商品详情-SPU_INFO查询条件
	 * 
	 * @return viewModelCondition [枚举]展示模块：0-商品详情-SPU_INFO查询条件
	 */
	public Condition<CouponTemplateViewModel> viewModel() {
		this.viewModelCondition = new Condition<>();
		return this.viewModelCondition;
	}
	
	/**
	 * 获取[枚举]展示模块：0-商品详情-SPU_INFO查询条件
	 * 
	 * @return viewModelCondition [枚举]展示模块：0-商品详情-SPU_INFO查询条件
	 */
	public Condition<CouponTemplateViewModel> getViewModelCondition() {
		return viewModelCondition;
	}

	/**
	 * 设置[枚举]展示模块：0-商品详情-SPU_INFO查询条件
	 * 
	 * @param viewModelCondition [枚举]展示模块：0-商品详情-SPU_INFO查询条件
	 */
	public void setViewModelCondition(Condition<CouponTemplateViewModel> viewModelCondition) {
		this.viewModelCondition = viewModelCondition;
	}

	/**
	 * 构造并返回展示开始时间查询条件
	 * 
	 * @return viewStartTimeCondition 展示开始时间查询条件
	 */
	public Condition<LocalDateTime> viewStartTime() {
		this.viewStartTimeCondition = new Condition<>();
		return this.viewStartTimeCondition;
	}
	
	/**
	 * 获取展示开始时间查询条件
	 * 
	 * @return viewStartTimeCondition 展示开始时间查询条件
	 */
	public Condition<LocalDateTime> getViewStartTimeCondition() {
		return viewStartTimeCondition;
	}

	/**
	 * 设置展示开始时间查询条件
	 * 
	 * @param viewStartTimeCondition 展示开始时间查询条件
	 */
	public void setViewStartTimeCondition(Condition<LocalDateTime> viewStartTimeCondition) {
		this.viewStartTimeCondition = viewStartTimeCondition;
	}

	/**
	 * 构造并返回展示结束时间查询条件
	 * 
	 * @return viewEndTimeCondition 展示结束时间查询条件
	 */
	public Condition<LocalDateTime> viewEndTime() {
		this.viewEndTimeCondition = new Condition<>();
		return this.viewEndTimeCondition;
	}
	
	/**
	 * 获取展示结束时间查询条件
	 * 
	 * @return viewEndTimeCondition 展示结束时间查询条件
	 */
	public Condition<LocalDateTime> getViewEndTimeCondition() {
		return viewEndTimeCondition;
	}

	/**
	 * 设置展示结束时间查询条件
	 * 
	 * @param viewEndTimeCondition 展示结束时间查询条件
	 */
	public void setViewEndTimeCondition(Condition<LocalDateTime> viewEndTimeCondition) {
		this.viewEndTimeCondition = viewEndTimeCondition;
	}

	/**
	 * 构造并返回[枚举]使用范围：0-全体商品-ALL、1-指定商圈-BUSINESS_DISTRICT、2-指定商户-MERCHANT、3-指定产品-SPU、4-指定商品类目-PRODUCT_CATEGORY、5-排除指定产品-EXCLUDE_SPU查询条件
	 * 
	 * @return scopeCondition [枚举]使用范围：0-全体商品-ALL、1-指定商圈-BUSINESS_DISTRICT、2-指定商户-MERCHANT、3-指定产品-SPU、4-指定商品类目-PRODUCT_CATEGORY、5-排除指定产品-EXCLUDE_SPU查询条件
	 */
	public Condition<CouponTemplateScope> scope() {
		this.scopeCondition = new Condition<>();
		return this.scopeCondition;
	}
	
	/**
	 * 获取[枚举]使用范围：0-全体商品-ALL、1-指定商圈-BUSINESS_DISTRICT、2-指定商户-MERCHANT、3-指定产品-SPU、4-指定商品类目-PRODUCT_CATEGORY、5-排除指定产品-EXCLUDE_SPU查询条件
	 * 
	 * @return scopeCondition [枚举]使用范围：0-全体商品-ALL、1-指定商圈-BUSINESS_DISTRICT、2-指定商户-MERCHANT、3-指定产品-SPU、4-指定商品类目-PRODUCT_CATEGORY、5-排除指定产品-EXCLUDE_SPU查询条件
	 */
	public Condition<CouponTemplateScope> getScopeCondition() {
		return scopeCondition;
	}

	/**
	 * 设置[枚举]使用范围：0-全体商品-ALL、1-指定商圈-BUSINESS_DISTRICT、2-指定商户-MERCHANT、3-指定产品-SPU、4-指定商品类目-PRODUCT_CATEGORY、5-排除指定产品-EXCLUDE_SPU查询条件
	 * 
	 * @param scopeCondition [枚举]使用范围：0-全体商品-ALL、1-指定商圈-BUSINESS_DISTRICT、2-指定商户-MERCHANT、3-指定产品-SPU、4-指定商品类目-PRODUCT_CATEGORY、5-排除指定产品-EXCLUDE_SPU查询条件
	 */
	public void setScopeCondition(Condition<CouponTemplateScope> scopeCondition) {
		this.scopeCondition = scopeCondition;
	}

	/**
	 * 构造并返回支持的使用场景（把数字看为二进制序列，从右往左数，第0位表示：悦币充值、第1位表示：购买悦卡、第2位表示：会员向商户支付、第3位表示：购买优惠券、第4位表示：购买券包、第5位表示：组局订单、第6位表示：购买实物商品、第7位表示：停车支付）查询条件
	 * 
	 * @return sceneCondition 支持的使用场景（把数字看为二进制序列，从右往左数，第0位表示：悦币充值、第1位表示：购买悦卡、第2位表示：会员向商户支付、第3位表示：购买优惠券、第4位表示：购买券包、第5位表示：组局订单、第6位表示：购买实物商品、第7位表示：停车支付）查询条件
	 */
	public Condition<Integer> scene() {
		this.sceneCondition = new Condition<>();
		return this.sceneCondition;
	}
	
	/**
	 * 获取支持的使用场景（把数字看为二进制序列，从右往左数，第0位表示：悦币充值、第1位表示：购买悦卡、第2位表示：会员向商户支付、第3位表示：购买优惠券、第4位表示：购买券包、第5位表示：组局订单、第6位表示：购买实物商品、第7位表示：停车支付）查询条件
	 * 
	 * @return sceneCondition 支持的使用场景（把数字看为二进制序列，从右往左数，第0位表示：悦币充值、第1位表示：购买悦卡、第2位表示：会员向商户支付、第3位表示：购买优惠券、第4位表示：购买券包、第5位表示：组局订单、第6位表示：购买实物商品、第7位表示：停车支付）查询条件
	 */
	public Condition<Integer> getSceneCondition() {
		return sceneCondition;
	}

	/**
	 * 设置支持的使用场景（把数字看为二进制序列，从右往左数，第0位表示：悦币充值、第1位表示：购买悦卡、第2位表示：会员向商户支付、第3位表示：购买优惠券、第4位表示：购买券包、第5位表示：组局订单、第6位表示：购买实物商品、第7位表示：停车支付）查询条件
	 * 
	 * @param sceneCondition 支持的使用场景（把数字看为二进制序列，从右往左数，第0位表示：悦币充值、第1位表示：购买悦卡、第2位表示：会员向商户支付、第3位表示：购买优惠券、第4位表示：购买券包、第5位表示：组局订单、第6位表示：购买实物商品、第7位表示：停车支付）查询条件
	 */
	public void setSceneCondition(Condition<Integer> sceneCondition) {
		this.sceneCondition = sceneCondition;
	}

	/**
	 * 构造并返回支持的币种（把数字看为二进制序列，从右往左数，第0位表示：悦币、第1位表示：发放的悦卡、第2位表示：购买的悦卡、第3位表示：积分、第4位表示：第三方钱包）查询条件
	 * 
	 * @return currencyCondition 支持的币种（把数字看为二进制序列，从右往左数，第0位表示：悦币、第1位表示：发放的悦卡、第2位表示：购买的悦卡、第3位表示：积分、第4位表示：第三方钱包）查询条件
	 */
	public Condition<Integer> currency() {
		this.currencyCondition = new Condition<>();
		return this.currencyCondition;
	}
	
	/**
	 * 获取支持的币种（把数字看为二进制序列，从右往左数，第0位表示：悦币、第1位表示：发放的悦卡、第2位表示：购买的悦卡、第3位表示：积分、第4位表示：第三方钱包）查询条件
	 * 
	 * @return currencyCondition 支持的币种（把数字看为二进制序列，从右往左数，第0位表示：悦币、第1位表示：发放的悦卡、第2位表示：购买的悦卡、第3位表示：积分、第4位表示：第三方钱包）查询条件
	 */
	public Condition<Integer> getCurrencyCondition() {
		return currencyCondition;
	}

	/**
	 * 设置支持的币种（把数字看为二进制序列，从右往左数，第0位表示：悦币、第1位表示：发放的悦卡、第2位表示：购买的悦卡、第3位表示：积分、第4位表示：第三方钱包）查询条件
	 * 
	 * @param currencyCondition 支持的币种（把数字看为二进制序列，从右往左数，第0位表示：悦币、第1位表示：发放的悦卡、第2位表示：购买的悦卡、第3位表示：积分、第4位表示：第三方钱包）查询条件
	 */
	public void setCurrencyCondition(Condition<Integer> currencyCondition) {
		this.currencyCondition = currencyCondition;
	}

	/**
	 * 构造并返回支持的获取优惠券通道（把数字看为二进制序列，从右往左数，第0位表示：购买、第1位表示：积分兑换、第2位表示：小票兑换）查询条件
	 * 
	 * @return channelCondition 支持的获取优惠券通道（把数字看为二进制序列，从右往左数，第0位表示：购买、第1位表示：积分兑换、第2位表示：小票兑换）查询条件
	 */
	public Condition<Integer> channel() {
		this.channelCondition = new Condition<>();
		return this.channelCondition;
	}
	
	/**
	 * 获取支持的获取优惠券通道（把数字看为二进制序列，从右往左数，第0位表示：购买、第1位表示：积分兑换、第2位表示：小票兑换）查询条件
	 * 
	 * @return channelCondition 支持的获取优惠券通道（把数字看为二进制序列，从右往左数，第0位表示：购买、第1位表示：积分兑换、第2位表示：小票兑换）查询条件
	 */
	public Condition<Integer> getChannelCondition() {
		return channelCondition;
	}

	/**
	 * 设置支持的获取优惠券通道（把数字看为二进制序列，从右往左数，第0位表示：购买、第1位表示：积分兑换、第2位表示：小票兑换）查询条件
	 * 
	 * @param channelCondition 支持的获取优惠券通道（把数字看为二进制序列，从右往左数，第0位表示：购买、第1位表示：积分兑换、第2位表示：小票兑换）查询条件
	 */
	public void setChannelCondition(Condition<Integer> channelCondition) {
		this.channelCondition = channelCondition;
	}

	/**
	 * 构造并返回[枚举]优惠券类型：0-停车券-PARK、1-现金券-CASH查询条件
	 * 
	 * @return typeCondition [枚举]优惠券类型：0-停车券-PARK、1-现金券-CASH查询条件
	 */
	public Condition<CouponTemplateType> type() {
		this.typeCondition = new Condition<>();
		return this.typeCondition;
	}
	
	/**
	 * 获取[枚举]优惠券类型：0-停车券-PARK、1-现金券-CASH查询条件
	 * 
	 * @return typeCondition [枚举]优惠券类型：0-停车券-PARK、1-现金券-CASH查询条件
	 */
	public Condition<CouponTemplateType> getTypeCondition() {
		return typeCondition;
	}

	/**
	 * 设置[枚举]优惠券类型：0-停车券-PARK、1-现金券-CASH查询条件
	 * 
	 * @param typeCondition [枚举]优惠券类型：0-停车券-PARK、1-现金券-CASH查询条件
	 */
	public void setTypeCondition(Condition<CouponTemplateType> typeCondition) {
		this.typeCondition = typeCondition;
	}

	/**
	 * 构造并返回[枚举]优惠形式：0-抵扣券-DEDUCATION、1-折扣券-DISCOUNT、2-随机券-RANDOM查询条件
	 * 
	 * @return formatCondition [枚举]优惠形式：0-抵扣券-DEDUCATION、1-折扣券-DISCOUNT、2-随机券-RANDOM查询条件
	 */
	public Condition<CouponTemplateFormat> format() {
		this.formatCondition = new Condition<>();
		return this.formatCondition;
	}
	
	/**
	 * 获取[枚举]优惠形式：0-抵扣券-DEDUCATION、1-折扣券-DISCOUNT、2-随机券-RANDOM查询条件
	 * 
	 * @return formatCondition [枚举]优惠形式：0-抵扣券-DEDUCATION、1-折扣券-DISCOUNT、2-随机券-RANDOM查询条件
	 */
	public Condition<CouponTemplateFormat> getFormatCondition() {
		return formatCondition;
	}

	/**
	 * 设置[枚举]优惠形式：0-抵扣券-DEDUCATION、1-折扣券-DISCOUNT、2-随机券-RANDOM查询条件
	 * 
	 * @param formatCondition [枚举]优惠形式：0-抵扣券-DEDUCATION、1-折扣券-DISCOUNT、2-随机券-RANDOM查询条件
	 */
	public void setFormatCondition(Condition<CouponTemplateFormat> formatCondition) {
		this.formatCondition = formatCondition;
	}

	/**
	 * 构造并返回[抵扣券]抵扣金额（0.00表示无抵扣）[随机券]最高总金额查询条件
	 * 
	 * @return reductionMountCondition [抵扣券]抵扣金额（0.00表示无抵扣）[随机券]最高总金额查询条件
	 */
	public Condition<BigDecimal> reductionMount() {
		this.reductionMountCondition = new Condition<>();
		return this.reductionMountCondition;
	}
	
	/**
	 * 获取[抵扣券]抵扣金额（0.00表示无抵扣）[随机券]最高总金额查询条件
	 * 
	 * @return reductionMountCondition [抵扣券]抵扣金额（0.00表示无抵扣）[随机券]最高总金额查询条件
	 */
	public Condition<BigDecimal> getReductionMountCondition() {
		return reductionMountCondition;
	}

	/**
	 * 设置[抵扣券]抵扣金额（0.00表示无抵扣）[随机券]最高总金额查询条件
	 * 
	 * @param reductionMountCondition [抵扣券]抵扣金额（0.00表示无抵扣）[随机券]最高总金额查询条件
	 */
	public void setReductionMountCondition(Condition<BigDecimal> reductionMountCondition) {
		this.reductionMountCondition = reductionMountCondition;
	}

	/**
	 * 构造并返回[折扣券]折扣率（0.00~1.00，例如九五折：0.95，1.00表示无折扣）查询条件
	 * 
	 * @return discountRateCondition [折扣券]折扣率（0.00~1.00，例如九五折：0.95，1.00表示无折扣）查询条件
	 */
	public Condition<BigDecimal> discountRate() {
		this.discountRateCondition = new Condition<>();
		return this.discountRateCondition;
	}
	
	/**
	 * 获取[折扣券]折扣率（0.00~1.00，例如九五折：0.95，1.00表示无折扣）查询条件
	 * 
	 * @return discountRateCondition [折扣券]折扣率（0.00~1.00，例如九五折：0.95，1.00表示无折扣）查询条件
	 */
	public Condition<BigDecimal> getDiscountRateCondition() {
		return discountRateCondition;
	}

	/**
	 * 设置[折扣券]折扣率（0.00~1.00，例如九五折：0.95，1.00表示无折扣）查询条件
	 * 
	 * @param discountRateCondition [折扣券]折扣率（0.00~1.00，例如九五折：0.95，1.00表示无折扣）查询条件
	 */
	public void setDiscountRateCondition(Condition<BigDecimal> discountRateCondition) {
		this.discountRateCondition = discountRateCondition;
	}

	/**
	 * 构造并返回[随机券]抵扣金额下限查询条件
	 * 
	 * @return lowerDiscountCondition [随机券]抵扣金额下限查询条件
	 */
	public Condition<BigDecimal> lowerDiscount() {
		this.lowerDiscountCondition = new Condition<>();
		return this.lowerDiscountCondition;
	}
	
	/**
	 * 获取[随机券]抵扣金额下限查询条件
	 * 
	 * @return lowerDiscountCondition [随机券]抵扣金额下限查询条件
	 */
	public Condition<BigDecimal> getLowerDiscountCondition() {
		return lowerDiscountCondition;
	}

	/**
	 * 设置[随机券]抵扣金额下限查询条件
	 * 
	 * @param lowerDiscountCondition [随机券]抵扣金额下限查询条件
	 */
	public void setLowerDiscountCondition(Condition<BigDecimal> lowerDiscountCondition) {
		this.lowerDiscountCondition = lowerDiscountCondition;
	}

	/**
	 * 构造并返回[随机券]抵扣金额上限查询条件
	 * 
	 * @return upperDiscountCondition [随机券]抵扣金额上限查询条件
	 */
	public Condition<BigDecimal> upperDiscount() {
		this.upperDiscountCondition = new Condition<>();
		return this.upperDiscountCondition;
	}
	
	/**
	 * 获取[随机券]抵扣金额上限查询条件
	 * 
	 * @return upperDiscountCondition [随机券]抵扣金额上限查询条件
	 */
	public Condition<BigDecimal> getUpperDiscountCondition() {
		return upperDiscountCondition;
	}

	/**
	 * 设置[随机券]抵扣金额上限查询条件
	 * 
	 * @param upperDiscountCondition [随机券]抵扣金额上限查询条件
	 */
	public void setUpperDiscountCondition(Condition<BigDecimal> upperDiscountCondition) {
		this.upperDiscountCondition = upperDiscountCondition;
	}

	/**
	 * 构造并返回使用门槛下限（包含，即订单满多少才能使用，-1.00表示不限制）查询条件
	 * 
	 * @return lowerLimitCondition 使用门槛下限（包含，即订单满多少才能使用，-1.00表示不限制）查询条件
	 */
	public Condition<BigDecimal> lowerLimit() {
		this.lowerLimitCondition = new Condition<>();
		return this.lowerLimitCondition;
	}
	
	/**
	 * 获取使用门槛下限（包含，即订单满多少才能使用，-1.00表示不限制）查询条件
	 * 
	 * @return lowerLimitCondition 使用门槛下限（包含，即订单满多少才能使用，-1.00表示不限制）查询条件
	 */
	public Condition<BigDecimal> getLowerLimitCondition() {
		return lowerLimitCondition;
	}

	/**
	 * 设置使用门槛下限（包含，即订单满多少才能使用，-1.00表示不限制）查询条件
	 * 
	 * @param lowerLimitCondition 使用门槛下限（包含，即订单满多少才能使用，-1.00表示不限制）查询条件
	 */
	public void setLowerLimitCondition(Condition<BigDecimal> lowerLimitCondition) {
		this.lowerLimitCondition = lowerLimitCondition;
	}

	/**
	 * 构造并返回使用门槛上限（包含，-1.00表示不限制）查询条件
	 * 
	 * @return upperLimitCondition 使用门槛上限（包含，-1.00表示不限制）查询条件
	 */
	public Condition<BigDecimal> upperLimit() {
		this.upperLimitCondition = new Condition<>();
		return this.upperLimitCondition;
	}
	
	/**
	 * 获取使用门槛上限（包含，-1.00表示不限制）查询条件
	 * 
	 * @return upperLimitCondition 使用门槛上限（包含，-1.00表示不限制）查询条件
	 */
	public Condition<BigDecimal> getUpperLimitCondition() {
		return upperLimitCondition;
	}

	/**
	 * 设置使用门槛上限（包含，-1.00表示不限制）查询条件
	 * 
	 * @param upperLimitCondition 使用门槛上限（包含，-1.00表示不限制）查询条件
	 */
	public void setUpperLimitCondition(Condition<BigDecimal> upperLimitCondition) {
		this.upperLimitCondition = upperLimitCondition;
	}

	/**
	 * 构造并返回每人限领张数（-1表示不限制）查询条件
	 * 
	 * @return personalLimitCondition 每人限领张数（-1表示不限制）查询条件
	 */
	public Condition<Integer> personalLimit() {
		this.personalLimitCondition = new Condition<>();
		return this.personalLimitCondition;
	}
	
	/**
	 * 获取每人限领张数（-1表示不限制）查询条件
	 * 
	 * @return personalLimitCondition 每人限领张数（-1表示不限制）查询条件
	 */
	public Condition<Integer> getPersonalLimitCondition() {
		return personalLimitCondition;
	}

	/**
	 * 设置每人限领张数（-1表示不限制）查询条件
	 * 
	 * @param personalLimitCondition 每人限领张数（-1表示不限制）查询条件
	 */
	public void setPersonalLimitCondition(Condition<Integer> personalLimitCondition) {
		this.personalLimitCondition = personalLimitCondition;
	}

	/**
	 * 构造并返回每人/每天限领张数（-1表示不限制）查询条件
	 * 
	 * @return personalDayLimitCondition 每人/每天限领张数（-1表示不限制）查询条件
	 */
	public Condition<Integer> personalDayLimit() {
		this.personalDayLimitCondition = new Condition<>();
		return this.personalDayLimitCondition;
	}
	
	/**
	 * 获取每人/每天限领张数（-1表示不限制）查询条件
	 * 
	 * @return personalDayLimitCondition 每人/每天限领张数（-1表示不限制）查询条件
	 */
	public Condition<Integer> getPersonalDayLimitCondition() {
		return personalDayLimitCondition;
	}

	/**
	 * 设置每人/每天限领张数（-1表示不限制）查询条件
	 * 
	 * @param personalDayLimitCondition 每人/每天限领张数（-1表示不限制）查询条件
	 */
	public void setPersonalDayLimitCondition(Condition<Integer> personalDayLimitCondition) {
		this.personalDayLimitCondition = personalDayLimitCondition;
	}

	/**
	 * 构造并返回会员等级限制（-1表示不限制，1表示等级大于等于1级的会员可以用，以此类推）查询条件
	 * 
	 * @return memberLevelLimitCondition 会员等级限制（-1表示不限制，1表示等级大于等于1级的会员可以用，以此类推）查询条件
	 */
	public Condition<Integer> memberLevelLimit() {
		this.memberLevelLimitCondition = new Condition<>();
		return this.memberLevelLimitCondition;
	}
	
	/**
	 * 获取会员等级限制（-1表示不限制，1表示等级大于等于1级的会员可以用，以此类推）查询条件
	 * 
	 * @return memberLevelLimitCondition 会员等级限制（-1表示不限制，1表示等级大于等于1级的会员可以用，以此类推）查询条件
	 */
	public Condition<Integer> getMemberLevelLimitCondition() {
		return memberLevelLimitCondition;
	}

	/**
	 * 设置会员等级限制（-1表示不限制，1表示等级大于等于1级的会员可以用，以此类推）查询条件
	 * 
	 * @param memberLevelLimitCondition 会员等级限制（-1表示不限制，1表示等级大于等于1级的会员可以用，以此类推）查询条件
	 */
	public void setMemberLevelLimitCondition(Condition<Integer> memberLevelLimitCondition) {
		this.memberLevelLimitCondition = memberLevelLimitCondition;
	}

	/**
	 * 构造并返回是否允许售卖（1：允许售卖、2：不允许售卖）查询条件
	 * 
	 * @return allowSaleCondition 是否允许售卖（1：允许售卖、2：不允许售卖）查询条件
	 */
	public Condition<Boolean> allowSale() {
		this.allowSaleCondition = new Condition<>();
		return this.allowSaleCondition;
	}
	
	/**
	 * 获取是否允许售卖（1：允许售卖、2：不允许售卖）查询条件
	 * 
	 * @return allowSaleCondition 是否允许售卖（1：允许售卖、2：不允许售卖）查询条件
	 */
	public Condition<Boolean> getAllowSaleCondition() {
		return allowSaleCondition;
	}

	/**
	 * 设置是否允许售卖（1：允许售卖、2：不允许售卖）查询条件
	 * 
	 * @param allowSaleCondition 是否允许售卖（1：允许售卖、2：不允许售卖）查询条件
	 */
	public void setAllowSaleCondition(Condition<Boolean> allowSaleCondition) {
		this.allowSaleCondition = allowSaleCondition;
	}

	/**
	 * 构造并返回是否允许重叠查询条件
	 * 
	 * @return allowCpysCondition 是否允许重叠查询条件
	 */
	public Condition<Boolean> allowCpys() {
		this.allowCpysCondition = new Condition<>();
		return this.allowCpysCondition;
	}
	
	/**
	 * 获取是否允许重叠查询条件
	 * 
	 * @return allowCpysCondition 是否允许重叠查询条件
	 */
	public Condition<Boolean> getAllowCpysCondition() {
		return allowCpysCondition;
	}

	/**
	 * 设置是否允许重叠查询条件
	 * 
	 * @param allowCpysCondition 是否允许重叠查询条件
	 */
	public void setAllowCpysCondition(Condition<Boolean> allowCpysCondition) {
		this.allowCpysCondition = allowCpysCondition;
	}

	/**
	 * 构造并返回提前预警小时查询条件
	 * 
	 * @return expireWarnHourCondition 提前预警小时查询条件
	 */
	public Condition<Integer> expireWarnHour() {
		this.expireWarnHourCondition = new Condition<>();
		return this.expireWarnHourCondition;
	}
	
	/**
	 * 获取提前预警小时查询条件
	 * 
	 * @return expireWarnHourCondition 提前预警小时查询条件
	 */
	public Condition<Integer> getExpireWarnHourCondition() {
		return expireWarnHourCondition;
	}

	/**
	 * 设置提前预警小时查询条件
	 * 
	 * @param expireWarnHourCondition 提前预警小时查询条件
	 */
	public void setExpireWarnHourCondition(Condition<Integer> expireWarnHourCondition) {
		this.expireWarnHourCondition = expireWarnHourCondition;
	}

	/**
	 * 构造并返回[枚举]分摊方式：0-百分比-SCALE、1-现金-CASH查询条件
	 * 
	 * @return divideTypeCondition [枚举]分摊方式：0-百分比-SCALE、1-现金-CASH查询条件
	 */
	public Condition<CouponTemplateDivideType> divideType() {
		this.divideTypeCondition = new Condition<>();
		return this.divideTypeCondition;
	}
	
	/**
	 * 获取[枚举]分摊方式：0-百分比-SCALE、1-现金-CASH查询条件
	 * 
	 * @return divideTypeCondition [枚举]分摊方式：0-百分比-SCALE、1-现金-CASH查询条件
	 */
	public Condition<CouponTemplateDivideType> getDivideTypeCondition() {
		return divideTypeCondition;
	}

	/**
	 * 设置[枚举]分摊方式：0-百分比-SCALE、1-现金-CASH查询条件
	 * 
	 * @param divideTypeCondition [枚举]分摊方式：0-百分比-SCALE、1-现金-CASH查询条件
	 */
	public void setDivideTypeCondition(Condition<CouponTemplateDivideType> divideTypeCondition) {
		this.divideTypeCondition = divideTypeCondition;
	}

	/**
	 * 构造并返回商户分摊（现金或者比例，比例之和=1，现金之和=reduction_mount）查询条件
	 * 
	 * @return divideMerchantCondition 商户分摊（现金或者比例，比例之和=1，现金之和=reduction_mount）查询条件
	 */
	public Condition<BigDecimal> divideMerchant() {
		this.divideMerchantCondition = new Condition<>();
		return this.divideMerchantCondition;
	}
	
	/**
	 * 获取商户分摊（现金或者比例，比例之和=1，现金之和=reduction_mount）查询条件
	 * 
	 * @return divideMerchantCondition 商户分摊（现金或者比例，比例之和=1，现金之和=reduction_mount）查询条件
	 */
	public Condition<BigDecimal> getDivideMerchantCondition() {
		return divideMerchantCondition;
	}

	/**
	 * 设置商户分摊（现金或者比例，比例之和=1，现金之和=reduction_mount）查询条件
	 * 
	 * @param divideMerchantCondition 商户分摊（现金或者比例，比例之和=1，现金之和=reduction_mount）查询条件
	 */
	public void setDivideMerchantCondition(Condition<BigDecimal> divideMerchantCondition) {
		this.divideMerchantCondition = divideMerchantCondition;
	}

	/**
	 * 构造并返回平台分摊（现金或者比例，比例之和=1，现金之和=reduction_mount）查询条件
	 * 
	 * @return divideGroupCondition 平台分摊（现金或者比例，比例之和=1，现金之和=reduction_mount）查询条件
	 */
	public Condition<BigDecimal> divideGroup() {
		this.divideGroupCondition = new Condition<>();
		return this.divideGroupCondition;
	}
	
	/**
	 * 获取平台分摊（现金或者比例，比例之和=1，现金之和=reduction_mount）查询条件
	 * 
	 * @return divideGroupCondition 平台分摊（现金或者比例，比例之和=1，现金之和=reduction_mount）查询条件
	 */
	public Condition<BigDecimal> getDivideGroupCondition() {
		return divideGroupCondition;
	}

	/**
	 * 设置平台分摊（现金或者比例，比例之和=1，现金之和=reduction_mount）查询条件
	 * 
	 * @param divideGroupCondition 平台分摊（现金或者比例，比例之和=1，现金之和=reduction_mount）查询条件
	 */
	public void setDivideGroupCondition(Condition<BigDecimal> divideGroupCondition) {
		this.divideGroupCondition = divideGroupCondition;
	}

	/**
	 * 构造并返回优惠券描述查询条件
	 * 
	 * @return discriptionCondition 优惠券描述查询条件
	 */
	public Condition<String> discription() {
		this.discriptionCondition = new Condition<>();
		return this.discriptionCondition;
	}
	
	/**
	 * 获取优惠券描述查询条件
	 * 
	 * @return discriptionCondition 优惠券描述查询条件
	 */
	public Condition<String> getDiscriptionCondition() {
		return discriptionCondition;
	}

	/**
	 * 设置优惠券描述查询条件
	 * 
	 * @param discriptionCondition 优惠券描述查询条件
	 */
	public void setDiscriptionCondition(Condition<String> discriptionCondition) {
		this.discriptionCondition = discriptionCondition;
	}

	/**
	 * 构造并返回优惠券备注查询条件
	 * 
	 * @return remarksCondition 优惠券备注查询条件
	 */
	public Condition<String> remarks() {
		this.remarksCondition = new Condition<>();
		return this.remarksCondition;
	}
	
	/**
	 * 获取优惠券备注查询条件
	 * 
	 * @return remarksCondition 优惠券备注查询条件
	 */
	public Condition<String> getRemarksCondition() {
		return remarksCondition;
	}

	/**
	 * 设置优惠券备注查询条件
	 * 
	 * @param remarksCondition 优惠券备注查询条件
	 */
	public void setRemarksCondition(Condition<String> remarksCondition) {
		this.remarksCondition = remarksCondition;
	}

	/**
	 * 构造并返回排序号查询条件
	 * 
	 * @return sortCondition 排序号查询条件
	 */
	public Condition<Integer> sort() {
		this.sortCondition = new Condition<>();
		return this.sortCondition;
	}
	
	/**
	 * 获取排序号查询条件
	 * 
	 * @return sortCondition 排序号查询条件
	 */
	public Condition<Integer> getSortCondition() {
		return sortCondition;
	}

	/**
	 * 设置排序号查询条件
	 * 
	 * @param sortCondition 排序号查询条件
	 */
	public void setSortCondition(Condition<Integer> sortCondition) {
		this.sortCondition = sortCondition;
	}

	/**
	 * 构造并返回[枚举]上架状态：0-已下架-OFF_SHELF、1-已上架-ON_SHELF查询条件
	 * 
	 * @return shelfStatusCondition [枚举]上架状态：0-已下架-OFF_SHELF、1-已上架-ON_SHELF查询条件
	 */
	public Condition<CouponTemplateShelfStatus> shelfStatus() {
		this.shelfStatusCondition = new Condition<>();
		return this.shelfStatusCondition;
	}
	
	/**
	 * 获取[枚举]上架状态：0-已下架-OFF_SHELF、1-已上架-ON_SHELF查询条件
	 * 
	 * @return shelfStatusCondition [枚举]上架状态：0-已下架-OFF_SHELF、1-已上架-ON_SHELF查询条件
	 */
	public Condition<CouponTemplateShelfStatus> getShelfStatusCondition() {
		return shelfStatusCondition;
	}

	/**
	 * 设置[枚举]上架状态：0-已下架-OFF_SHELF、1-已上架-ON_SHELF查询条件
	 * 
	 * @param shelfStatusCondition [枚举]上架状态：0-已下架-OFF_SHELF、1-已上架-ON_SHELF查询条件
	 */
	public void setShelfStatusCondition(Condition<CouponTemplateShelfStatus> shelfStatusCondition) {
		this.shelfStatusCondition = shelfStatusCondition;
	}

	/**
	 * 构造并返回创建者查询条件
	 * 
	 * @return createdByCondition 创建者查询条件
	 */
	public Condition<String> createdBy() {
		this.createdByCondition = new Condition<>();
		return this.createdByCondition;
	}
	
	/**
	 * 获取创建者查询条件
	 * 
	 * @return createdByCondition 创建者查询条件
	 */
	public Condition<String> getCreatedByCondition() {
		return createdByCondition;
	}

	/**
	 * 设置创建者查询条件
	 * 
	 * @param createdByCondition 创建者查询条件
	 */
	public void setCreatedByCondition(Condition<String> createdByCondition) {
		this.createdByCondition = createdByCondition;
	}

	/**
	 * 构造并返回创建时间查询条件
	 * 
	 * @return createdTimeCondition 创建时间查询条件
	 */
	public Condition<LocalDateTime> createdTime() {
		this.createdTimeCondition = new Condition<>();
		return this.createdTimeCondition;
	}
	
	/**
	 * 获取创建时间查询条件
	 * 
	 * @return createdTimeCondition 创建时间查询条件
	 */
	public Condition<LocalDateTime> getCreatedTimeCondition() {
		return createdTimeCondition;
	}

	/**
	 * 设置创建时间查询条件
	 * 
	 * @param createdTimeCondition 创建时间查询条件
	 */
	public void setCreatedTimeCondition(Condition<LocalDateTime> createdTimeCondition) {
		this.createdTimeCondition = createdTimeCondition;
	}

	/**
	 * 构造并返回修改人查询条件
	 * 
	 * @return modifiedByCondition 修改人查询条件
	 */
	public Condition<String> modifiedBy() {
		this.modifiedByCondition = new Condition<>();
		return this.modifiedByCondition;
	}
	
	/**
	 * 获取修改人查询条件
	 * 
	 * @return modifiedByCondition 修改人查询条件
	 */
	public Condition<String> getModifiedByCondition() {
		return modifiedByCondition;
	}

	/**
	 * 设置修改人查询条件
	 * 
	 * @param modifiedByCondition 修改人查询条件
	 */
	public void setModifiedByCondition(Condition<String> modifiedByCondition) {
		this.modifiedByCondition = modifiedByCondition;
	}

	/**
	 * 构造并返回修改时间查询条件
	 * 
	 * @return modifiedTimeCondition 修改时间查询条件
	 */
	public Condition<LocalDateTime> modifiedTime() {
		this.modifiedTimeCondition = new Condition<>();
		return this.modifiedTimeCondition;
	}
	
	/**
	 * 获取修改时间查询条件
	 * 
	 * @return modifiedTimeCondition 修改时间查询条件
	 */
	public Condition<LocalDateTime> getModifiedTimeCondition() {
		return modifiedTimeCondition;
	}

	/**
	 * 设置修改时间查询条件
	 * 
	 * @param modifiedTimeCondition 修改时间查询条件
	 */
	public void setModifiedTimeCondition(Condition<LocalDateTime> modifiedTimeCondition) {
		this.modifiedTimeCondition = modifiedTimeCondition;
	}

	/**
	 * 构造并返回是否删除（1：已删除，0：未删除）查询条件
	 * 
	 * @return delCondition 是否删除（1：已删除，0：未删除）查询条件
	 */
	public Condition<Boolean> del() {
		this.delCondition = new Condition<>();
		return this.delCondition;
	}
	
	/**
	 * 获取是否删除（1：已删除，0：未删除）查询条件
	 * 
	 * @return delCondition 是否删除（1：已删除，0：未删除）查询条件
	 */
	public Condition<Boolean> getDelCondition() {
		return delCondition;
	}

	/**
	 * 设置是否删除（1：已删除，0：未删除）查询条件
	 * 
	 * @param delCondition 是否删除（1：已删除，0：未删除）查询条件
	 */
	public void setDelCondition(Condition<Boolean> delCondition) {
		this.delCondition = delCondition;
	}

	/**
	 * 构造并返回删除人查询条件
	 * 
	 * @return delByCondition 删除人查询条件
	 */
	public Condition<String> delBy() {
		this.delByCondition = new Condition<>();
		return this.delByCondition;
	}
	
	/**
	 * 获取删除人查询条件
	 * 
	 * @return delByCondition 删除人查询条件
	 */
	public Condition<String> getDelByCondition() {
		return delByCondition;
	}

	/**
	 * 设置删除人查询条件
	 * 
	 * @param delByCondition 删除人查询条件
	 */
	public void setDelByCondition(Condition<String> delByCondition) {
		this.delByCondition = delByCondition;
	}

	/**
	 * 构造并返回删除时间查询条件
	 * 
	 * @return delTimeCondition 删除时间查询条件
	 */
	public Condition<LocalDateTime> delTime() {
		this.delTimeCondition = new Condition<>();
		return this.delTimeCondition;
	}
	
	/**
	 * 获取删除时间查询条件
	 * 
	 * @return delTimeCondition 删除时间查询条件
	 */
	public Condition<LocalDateTime> getDelTimeCondition() {
		return delTimeCondition;
	}

	/**
	 * 设置删除时间查询条件
	 * 
	 * @param delTimeCondition 删除时间查询条件
	 */
	public void setDelTimeCondition(Condition<LocalDateTime> delTimeCondition) {
		this.delTimeCondition = delTimeCondition;
	}

	/**
	 * 构造并返回[枚举]审核状态：0-待提交-NOT_SUBMITTED、1-审核中-CHECKING、2-已通过-PASSED、3-审核未通过-UNPASSED查询条件
	 * 
	 * @return checkedStatusCondition [枚举]审核状态：0-待提交-NOT_SUBMITTED、1-审核中-CHECKING、2-已通过-PASSED、3-审核未通过-UNPASSED查询条件
	 */
	public Condition<CouponTemplateCheckedStatus> checkedStatus() {
		this.checkedStatusCondition = new Condition<>();
		return this.checkedStatusCondition;
	}
	
	/**
	 * 获取[枚举]审核状态：0-待提交-NOT_SUBMITTED、1-审核中-CHECKING、2-已通过-PASSED、3-审核未通过-UNPASSED查询条件
	 * 
	 * @return checkedStatusCondition [枚举]审核状态：0-待提交-NOT_SUBMITTED、1-审核中-CHECKING、2-已通过-PASSED、3-审核未通过-UNPASSED查询条件
	 */
	public Condition<CouponTemplateCheckedStatus> getCheckedStatusCondition() {
		return checkedStatusCondition;
	}

	/**
	 * 设置[枚举]审核状态：0-待提交-NOT_SUBMITTED、1-审核中-CHECKING、2-已通过-PASSED、3-审核未通过-UNPASSED查询条件
	 * 
	 * @param checkedStatusCondition [枚举]审核状态：0-待提交-NOT_SUBMITTED、1-审核中-CHECKING、2-已通过-PASSED、3-审核未通过-UNPASSED查询条件
	 */
	public void setCheckedStatusCondition(Condition<CouponTemplateCheckedStatus> checkedStatusCondition) {
		this.checkedStatusCondition = checkedStatusCondition;
	}

	/**
	 * 构造并返回审核人查询条件
	 * 
	 * @return checkedByCondition 审核人查询条件
	 */
	public Condition<String> checkedBy() {
		this.checkedByCondition = new Condition<>();
		return this.checkedByCondition;
	}
	
	/**
	 * 获取审核人查询条件
	 * 
	 * @return checkedByCondition 审核人查询条件
	 */
	public Condition<String> getCheckedByCondition() {
		return checkedByCondition;
	}

	/**
	 * 设置审核人查询条件
	 * 
	 * @param checkedByCondition 审核人查询条件
	 */
	public void setCheckedByCondition(Condition<String> checkedByCondition) {
		this.checkedByCondition = checkedByCondition;
	}

	/**
	 * 构造并返回审核时间查询条件
	 * 
	 * @return checkedTimeCondition 审核时间查询条件
	 */
	public Condition<LocalDateTime> checkedTime() {
		this.checkedTimeCondition = new Condition<>();
		return this.checkedTimeCondition;
	}
	
	/**
	 * 获取审核时间查询条件
	 * 
	 * @return checkedTimeCondition 审核时间查询条件
	 */
	public Condition<LocalDateTime> getCheckedTimeCondition() {
		return checkedTimeCondition;
	}

	/**
	 * 设置审核时间查询条件
	 * 
	 * @param checkedTimeCondition 审核时间查询条件
	 */
	public void setCheckedTimeCondition(Condition<LocalDateTime> checkedTimeCondition) {
		this.checkedTimeCondition = checkedTimeCondition;
	}

	/**
	 * 构造并返回审核意见查询条件
	 * 
	 * @return checkedRemarkCondition 审核意见查询条件
	 */
	public Condition<String> checkedRemark() {
		this.checkedRemarkCondition = new Condition<>();
		return this.checkedRemarkCondition;
	}
	
	/**
	 * 获取审核意见查询条件
	 * 
	 * @return checkedRemarkCondition 审核意见查询条件
	 */
	public Condition<String> getCheckedRemarkCondition() {
		return checkedRemarkCondition;
	}

	/**
	 * 设置审核意见查询条件
	 * 
	 * @param checkedRemarkCondition 审核意见查询条件
	 */
	public void setCheckedRemarkCondition(Condition<String> checkedRemarkCondition) {
		this.checkedRemarkCondition = checkedRemarkCondition;
	}

}
